// 腾讯地图API密钥
const QQMAP_KEY = 'IP6BZ-VFXHT-SJIXQ-LOD5I-FUOXF-J7BPV';

// 是否使用模拟数据模式（默认为false，使用真实SDK）
const useMockData = false;

// 计算两点之间的距离（公里）
const calculateDistance = (lat1, lng1, lat2, lng2) => {
  const R = 6371; // 地球半径（公里）
  const dLat = (lat2 - lat1) * Math.PI / 180;
  const dLng = (lng2 - lng1) * Math.PI / 180;
  const a = 
    Math.sin(dLat/2) * Math.sin(dLat/2) +
    Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
    Math.sin(dLng/2) * Math.sin(dLng/2);
  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
  const distance = R * c;
  return distance < 1 ? (distance * 1000).toFixed(0) + 'm' : distance.toFixed(1) + 'km';
};

// 生成模拟搜索结果（作为降级方案）
const generateMockSearchResults = (keyword, lat, lng) => {
  console.log('生成模拟搜索结果，关键词:', keyword);
  
  // 模拟加油站数据
  const mockStations = [
    { name: '中国石油加油站', address: '附近主要道路旁', distance: 0.8 },
    { name: '中国石化加油站', address: '商业街路口', distance: 1.2 },
    { name: '壳牌加油站', address: '高速出口旁', distance: 1.5 },
    { name: '民营加油站', address: '社区附近', distance: 2.1 },
    { name: '延长壳牌加油站', address: '城市主干道', distance: 2.5 }
  ];
  
  // 转换为结果格式
  const results = mockStations
    .filter(station => keyword ? station.name.includes(keyword) : true)
    .map((station, index) => {
      // 生成基于原始坐标的随机偏移
      const latOffset = (Math.random() - 0.5) * 0.01;
      const lngOffset = (Math.random() - 0.5) * 0.01;
      
      return {
        id: `mock_${Date.now()}_${index}`,
        name: station.name,
        address: station.address,
        latitude: lat + latOffset,
        longitude: lng + lngOffset,
        distance: `${station.distance}km`,
        _distance: station.distance * 1000
      };
    });
  
  return { data: results, status: 0 };
};

// 使用本地SDK的searchPlaces函数
const searchPlaces = (keyword, lat, lng, radius = 5000) => {
  return new Promise((resolve) => {
    try {
      console.log(`searchPlaces - 使用本地SDK - 关键词: ${keyword}, 位置: ${lat},${lng}, 半径: ${radius}m`);
      
      // 检查是否使用模拟数据模式
      if (useMockData) {
        console.log('使用模拟数据模式搜索地点');
        const mockResults = generateMockSearchResults(keyword, lat, lng);
        resolve(mockResults);
        return;
      }
      
      // 尝试获取全局注入的QQMapWX（从main.ts中导入的本地SDK）
      let QQMapWXClass = null;
      
      // 尝试多种方式获取QQMapWX类
      try {
        // 1. 从globalThis获取
        if (typeof globalThis.QQMapWX !== 'undefined') {
          QQMapWXClass = globalThis.QQMapWX;
          console.log('✓ 成功获取全局QQMapWX类');
        }
        // 2. 从window获取（浏览器环境）
        else if (typeof window !== 'undefined' && window.QQMapWX) {
          QQMapWXClass = window.QQMapWX;
          console.log('✓ 从window获取QQMapWX类');
        }
        // 3. 尝试动态导入
        else {
          console.log('尝试动态导入QQMapWX');
          QQMapWXClass = require('../../static/js/qqmap-wx-jssdk.min.js');
          console.log('✓ 动态导入QQMapWX成功');
        }
      } catch (importError) {
        console.warn('获取QQMapWX类失败:', importError.message || String(importError));
      }
      
      // 如果成功获取到类，创建实例并使用
      if (QQMapWXClass) {
        try {
          const mapSDK = new QQMapWXClass({
            key: QQMAP_KEY
          });
          
          console.log('创建地图SDK实例成功，调用搜索接口');
          
          // 调用搜索接口
          mapSDK.search({
            keyword: keyword,
            location: `${lat},${lng}`,
            radius: radius,
            success: (res) => {
              console.log('地图SDK搜索成功，状态码:', res.status);
              
              if (res.status === 0) {
                if (res.data && res.data.length > 0) {
                  console.log(`搜索到${res.data.length}个地点`);
                  
                  // 转换数据格式
                  const formattedResults = res.data.map(item => ({
                    id: item.id || `sdk_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                    name: item.title || '未知地点',
                    address: item.address || '地址信息暂不可用',
                    latitude: item.location?.lat || lat,
                    longitude: item.location?.lng || lng,
                    distance: item._distance 
                      ? `${(item._distance / 1000).toFixed(1)}km` 
                      : calculateDistance(lat, lng, item.location?.lat || lat, item.location?.lng || lng),
                    _distance: item._distance || Math.random() * 5000
                  }));
                  
                  // 按距离排序
                  formattedResults.sort((a, b) => a._distance - b._distance);
                  
                  resolve({ data: formattedResults, status: 0 });
                } else {
                  console.log('搜索结果为空数组');
                  resolve({ data: [], status: 0 });
                }
              } else {
                console.warn(`搜索返回非成功状态: ${res.status}, 错误信息: ${res.message || '未知错误'}`);
                // 降级到模拟数据
                const mockResults = generateMockSearchResults(keyword, lat, lng);
                resolve(mockResults);
              }
            },
            fail: (error) => {
              console.error('地图SDK搜索失败:', error.message || error.errMsg || String(error));
              // 降级到模拟数据
              const mockResults = generateMockSearchResults(keyword, lat, lng);
              resolve(mockResults);
            }
          });
        } catch (initError) {
          console.error('初始化地图SDK实例失败:', initError.message || initError.errMsg || String(initError));
          // 降级到模拟数据
          const mockResults = generateMockSearchResults(keyword, lat, lng);
          resolve(mockResults);
        }
      } else {
        // 降级到直接使用WebService API
        console.warn('未找到QQMapWX类，使用WebService API直接请求');
        
        try {
          uni.request({
            url: 'https://apis.map.qq.com/ws/place/v1/search',
            method: 'GET',
            data: {
              keyword: encodeURIComponent(keyword),
              location: `${lat},${lng}`,
              radius: radius,
              key: QQMAP_KEY
            },
            success: (res) => {
              if (res.statusCode === 200 && res.data) {
                if (res.data.status === 0 && res.data.data && res.data.data.length > 0) {
                  console.log(`WebService API搜索成功，找到${res.data.data.length}个结果`);
                  
                  const formattedResults = res.data.data.map(item => ({
                    id: item.id || `api_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                    name: item.title || '未知地点',
                    address: item.address || '地址信息暂不可用',
                    latitude: item.location?.lat || lat,
                    longitude: item.location?.lng || lng,
                    distance: calculateDistance(lat, lng, item.location?.lat || lat, item.location?.lng || lng),
                    _distance: Math.random() * 5000
                  }));
                  
                  resolve({ data: formattedResults, status: 0 });
                } else {
                  console.log('WebService API返回空结果');
                  resolve({ data: [], status: res.data.status || 0 });
                }
              }
            },
            fail: (error) => {
              console.error('WebService API请求失败:', error);
              // 降级到模拟数据
              const mockResults = generateMockSearchResults(keyword, lat, lng);
              resolve(mockResults);
            }
          });
        } catch (apiError) {
          console.error('WebService API调用异常:', apiError);
          // 降级到模拟数据
          const mockResults = generateMockSearchResults(keyword, lat, lng);
          resolve(mockResults);
        }
      }
    } catch (error) {
      console.error('searchPlaces函数发生未预期异常:', error.message || String(error));
      // 最终降级到模拟数据
      const mockResults = generateMockSearchResults(keyword, lat, lng);
      resolve(mockResults);
    }
  });
};